// pages/order/order.js
import {
  checkPageLogin
} from '../../utils/login-check.js'
import {
  userAPI
} from '../../utils/api.js'

const app = getApp()

Page({
  data: {
    showLoginModal: false,
    hasUserInfo: false,
    tabList: [{
        name: '全部',
        status: 'all'
      },
      {
        name: '待支付',
        status: 'pending'
      },
      // {
      //   name: '已取消',
      //   status: 'pending'
      // },
      {
        name: '已完成',
        status: 'completed'
      }
    ],
    currentTab: 0,
    orders: [],
    filteredOrders: [],
    showOrderDetail: false,
    currentOrder: null
  },

  onLoad() {
    console.log('订单页面加载，订单数量：', this.data.orders.length)
    this.checkLoginStatus()
  },

  onShow() {
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 2
      })
    }

    // 每次显示页面时检查登录状态
    this.checkLoginStatus()
  },

  // 下拉刷新
  onPullDownRefresh() {
    if (this.data.hasUserInfo) {
      this.loadOrders()
    }
    wx.stopPullDownRefresh()
  },

  // 检查登录状态
  checkLoginStatus() {
    const token = wx.getStorageSync('token')
    console.log('checkLoginStatus', token)

    if (token) {
      // 有token，验证用户信息并加载订单
      this.verifyUserAndLoadOrders()
    } else {
      this.setData({
        hasUserInfo: false
      })
    }
  },

  // 验证用户信息并加载订单
  verifyUserAndLoadOrders() {
    console.log('验证用户信息并加载订单')
    userAPI.getUserProfile().then(userInfo => {
      console.log('验证用户信息成功:', userInfo)
      this.setData({
        hasUserInfo: true
      })
      // 加载订单列表
      this.loadOrders()
    }).catch(error => {
      console.error('验证用户信息失败:', error)
      // 验证失败，可能是token过期
      this.setData({
        hasUserInfo: false
      })
    })
  },

  // 加载订单列表
  loadOrders() {
    userAPI.getTradeList({
      page: 1,
      pageSize: 100
    }).then(response => {
      console.log('获取订单列表成功:', response)
      // 根据API返回的数据结构，订单列表在data.list中
      const orders = this.formatOrders(response.list || [])
      this.setData({
        orders
      }, () => {
        this.sortOrders()
        this.updateFilteredOrders()
      })
    }).catch(error => {
      console.error('获取订单列表失败:', error)

      // 检查是否是401错误
      if (error.statusCode === 401 || error.code === 401) {
        this.showLoginModal()
        return
      }

      this.setData({
        orders: []
      }, () => {
        this.updateFilteredOrders()
      })
    })
  },

  // 格式化订单数据
  formatOrders(orders) {
    console.log('开始格式化订单数据:', orders)

    return orders.map(order => {
      console.log('处理订单:', order.no, 'orders数组:', order.orders)

      // 处理商品列表 - 从orders数组中提取item信息
      const products = (order.orders || []).map(orderItem => {
        console.log('处理订单项:', orderItem)

        // 检查item是否为数组且为空，如果是则跳过
        if (Array.isArray(orderItem.item) && orderItem.item.length === 0) {
          console.log('跳过空的item数组')
          return null
        }

        // 检查payment是否为数组且为空，如果是则跳过
        if (Array.isArray(orderItem.payment) && orderItem.payment.length === 0) {
          console.log('跳过空的payment数组')
          return null
        }

        // 处理item字段 - 可能是对象或数组
        let item = {}
        if (Array.isArray(orderItem.item)) {
          // 如果是数组，取第一个元素
          item = orderItem.item[0] || {}
        } else if (orderItem.item && typeof orderItem.item === 'object') {
          // 如果是对象，直接使用
          item = orderItem.item
        }

        const product = {
          id: item.productId || orderItem.id,
          name: item.productName || orderItem.name,
          image: item.productImage || orderItem.image,
          price: item.price || orderItem.price || 0,
          quantity: item.quantity || orderItem.quantity || 0,
          skuName: item.variantName || orderItem.skuName || '',
          skuId: item.variantId || orderItem.skuId || null
        }
        console.log('格式化后的商品:', product)
        return product
      }).filter(product => product !== null) // 过滤掉null值

      // 计算总数量
      const totalQuantity = products.reduce((sum, product) => sum + (product.quantity || 0), 0)

      // 获取桌位信息
      const tableNumber = Array.isArray(order.restaurantTable) && order.restaurantTable.length > 0 ?
        (order.restaurantTable[0] && order.restaurantTable[0].name) :
        (order.tableNumber || order.tableNo)

      // 获取支付信息
      const payment = order.payment || {}
      const totalPrice = payment.amount || order.totalAmount || order.totalPrice || 0
      const originalPrice = payment.originAmount || order.originalAmount || order.originalPrice || totalPrice
      const discount = payment.discount || order.discountAmount || order.discount || 0

      const formattedOrder = {
        id: order.no || order.id,
        type: '堂食', // 根据deliveryType判断，1为堂食
        status: this.mapOrderStatus(order.status),
        statusText: this.getStatusText(order.status),
        products: products,
        totalQuantity: totalQuantity,
        totalPrice: totalPrice,
        originalPrice: originalPrice,
        discount: discount,
        createTime: order.createdAt,
        payTime: order.payAt,
        finishTime: order.finishTime || order.completedAt,
        tableNumber: tableNumber,
        paymentMethod: order.paymentMethod || order.payMethod,
        note: order.remark || order.note,
        contactPhone: order.contactPhone || order.phone,
        // 保存原始数据用于详情显示
        rawData: order
      }

      console.log('格式化后的订单:', formattedOrder)
      return formattedOrder
    })
  },

  // 格式化订单详情数据
  formatOrderDetail(order) {
    console.log('开始格式化订单详情数据:', order)

    // 处理商品列表 - 从orders数组中提取item信息
    const products = (order.orders || []).map(orderItem => {
      console.log('处理订单详情项:', orderItem)

      // 检查item是否为数组且为空，如果是则跳过
      if (Array.isArray(orderItem.item) && orderItem.item.length === 0) {
        console.log('跳过空的item数组')
        return null
      }

      // 检查payment是否为数组且为空，如果是则跳过
      // if (Array.isArray(orderItem.payment) && orderItem.payment.length === 0) {
      //   console.log('跳过空的payment数组')
      //   return null
      // }

      // 处理item字段 - 可能是对象或数组
      let item = {}
      if (Array.isArray(orderItem.item)) {
        // 如果是数组，取第一个元素
        item = orderItem.item[0] || {}
      } else if (orderItem.item && typeof orderItem.item === 'object') {
        // 如果是对象，直接使用
        item = orderItem.item
      }

      const product = {
        id: item.productId || orderItem.id,
        name: item.productName || orderItem.name,
        image: item.productImage || orderItem.image,
        price: item.price || orderItem.price || 0,
        quantity: item.quantity || orderItem.quantity || 0,
        skuName: item.variantName || orderItem.skuName || '',
        skuId: item.variantId || orderItem.skuId || null
      }
      console.log('格式化后的详情商品:', product)
      return product
    }).filter(product => product !== null) // 过滤掉null值

    // 计算总数量
    const totalQuantity = products.reduce((sum, product) => sum + (product.quantity || 0), 0)

    // 获取桌位信息
    const tableNumber = Array.isArray(order.restaurantTable) && order.restaurantTable.length > 0 ?
      (order.restaurantTable[0] && order.restaurantTable[0].name) :
      (order.tableNumber || order.tableNo)

    // 获取支付信息
    const payment = order.payment || {}
    const totalPrice = payment.amount || order.totalAmount || order.totalPrice || 0
    const originalPrice = payment.originAmount || order.originalAmount || order.originalPrice || totalPrice
    const discount = payment.discount || order.discountAmount || order.discount || 0
    const adjust = payment.adjust || 0

    const formattedOrder = {
      id: order.no || order.id,
      type: '堂食', // 根据deliveryType判断，1为堂食
      status: this.mapOrderStatus(order.status),
      statusText: this.getStatusText(order.status),
      products: products,
      totalQuantity: totalQuantity,
      totalPrice: totalPrice,
      originalPrice: originalPrice,
      adjust,
      discount: discount,
      createTime: order.createdAt,
      payTime: order.payAt,
      finishTime: order.finishTime || order.completedAt,
      tableNumber: tableNumber,
      paymentMethod: order.paymentMethod || order.payMethod,
      note: order.remark || order.note,
      contactPhone: order.contactPhone || order.phone,
      // 保存原始数据用于详情显示
      rawData: order
    }

    console.log('格式化后的订单详情:', formattedOrder)
    return formattedOrder
  },





  // 映射订单状态
  mapOrderStatus(status) {
    const statusMap = {
      1: 'pending', // 待支付
      2: 'completed', // 就餐中
      3: 'completed', // 已完成
      4: 'cancelled' // 已取消
    }
    return statusMap[status] || status
  },

  // 获取状态文本
  getStatusText(status) {
    const statusTextMap = {
      0: '已取消',
      1: '待支付',
      2: '已完成',
      3: '已完成',
      4: '已取消'
    }
    return statusTextMap[status] || status
  },

  // 排序订单
  sortOrders() {
    const orders = this.data.orders.sort((a, b) => {
      return new Date(b.createTime) - new Date(a.createTime)
    })
    this.setData({
      orders
    })
  },

  // 标签切换
  onTabTap(e) {
    const index = e.currentTarget.dataset.index
    console.log('切换到标签：', index, this.data.tabList[index])
    this.setData({
      currentTab: index
    }, () => {
      this.updateFilteredOrders()
    })
  },

  // 更新过滤后的订单
  updateFilteredOrders() {
    const {
      orders,
      tabList,
      currentTab
    } = this.data
    const status = tabList[currentTab].status

    console.log('过滤条件：', status, '原始订单数：', orders.length)

    let filteredOrders = []
    if (status === 'all') {
      filteredOrders = orders
    } else {
      filteredOrders = orders.filter(order => order.status === status)
    }

    console.log('过滤后订单数：', filteredOrders.length)

    // 调试：检查是否有pending状态的订单
    const pendingOrders = orders.filter(order => order.status === 'pending')
    console.log('待支付订单数量：', pendingOrders.length)
    if (pendingOrders.length > 0) {
      console.log('待支付订单详情：', pendingOrders)
    }

    this.setData({
      filteredOrders
    })
  },

  // 订单详情
  onOrderDetail(e) {
    const orderId = e.currentTarget.dataset.id
    const order = this.data.orders.find(item => item.id === orderId)

    console.log('查看订单详情：', orderId, order)

    if (order) {
      // 如果有基础订单信息，直接显示
      this.setData({
        showOrderDetail: true,
        currentOrder: order
      })

      // 同时获取详细订单信息，使用订单号
      const orderNo = order.id
      this.loadOrderDetail(orderNo)
    }
  },

  // 加载订单详情
  loadOrderDetail(orderNo) {
    userAPI.getTradeDetail(orderNo).then(response => {
      console.log('获取订单详情成功:', response)
      // 如果返回的是单个订单对象，包装成数组
      const orderData = response.info || response
      console.log('处理订单详情数据:', orderData)

      if (!orderData) {
        console.error('订单详情数据为空')
        return
      }

      // 直接处理订单详情数据，不使用formatOrders
      const detailOrder = this.formatOrderDetail(orderData)
      if (detailOrder) {
        this.setData({
          currentOrder: detailOrder
        })
      } else {
        console.error('格式化订单详情失败')
      }
    }).catch(error => {
      console.error('获取订单详情失败:', error)

      // 检查是否是401错误
      if (error.statusCode === 401 || error.code === 401) {
        this.showLoginModal()
        return
      }

      // 获取详情失败，使用基础信息
    })
  },

  // 关闭订单详情
  onCloseOrderDetail() {
    this.setData({
      showOrderDetail: false,
      currentOrder: null
    })
  },

  // 取消订单
  onCancelOrder(e) {
    const orderId = e.currentTarget.dataset.id

    wx.showModal({
      title: '确认取消',
      content: '确定要取消这个订单吗？',
      success: (res) => {
        if (res.confirm) {
          // 模拟取消订单
          wx.showLoading({
            title: '取消中...'
          })

          setTimeout(() => {
            wx.hideLoading()

            // 从订单列表中移除
            const orders = this.data.orders.filter(order => order.id !== orderId)
            this.setData({
              orders
            }, () => {
              this.updateFilteredOrders()
            })

            wx.showToast({
              title: '订单已取消',
              icon: 'success'
            })
          }, 1000)
        }
      }
    })
  },

  // 立即支付
  onPayOrder(e) {
    console.log('立即支付按钮被点击:', e)
    const orderId = e.currentTarget.dataset.id
    console.log('订单ID:', orderId)

    wx.showModal({
      title: '支付提示',
      content: '请移步前台买单，感谢谅解。',
      showCancel: false,
      confirmText: '知道了',
      success: (res) => {
        console.log('支付提示弹窗结果:', res)
      }
    })
  },

  // 再来一单
  onReorder(e) {
    const orderId = e.currentTarget.dataset.id
    const order = this.data.orders.find(item => item.id === orderId)

    if (order) {
      // 将订单商品添加到购物车
      const cart = order.products.map(product => ({
        id: product.id,
        skuId: product.skuName ? `sku_${product.id}` : null,
        name: product.name,
        image: product.image,
        price: product.price,
        quantity: product.quantity,
        skuName: product.skuName
      }))

      // 保存到全局购物车
      app.globalData.cart = cart

      wx.showModal({
        title: '再来一单',
        content: '已将商品添加到购物车，是否前往点餐页面？',
        success: (res) => {
          if (res.confirm) {
            wx.switchTab({
              url: '/pages/menu/menu'
            })
          }
        }
      })
    }
  },

  // 评价订单
  onRateOrder(e) {
    const orderId = e.currentTarget.dataset.id

    wx.showModal({
      title: '订单评价',
      content: '此功能将跳转到评价页面',
      showCancel: false,
      success: () => {
        // 这里可以跳转到评价页面
        // wx.navigateTo({
        //   url: `/pages/rating/rating?orderId=${orderId}`
        // })

        // 暂时模拟评价完成
        wx.showToast({
          title: '感谢您的评价',
          icon: 'success'
        })
      }
    })
  },

  // 联系客服
  onContactService(e) {
    const orderId = e.currentTarget.dataset.id

    wx.showModal({
      title: '联系客服',
      content: '客服电话：400-123-4567\n工作时间：9:00-22:00',
      showCancel: false
    })
  },

  // 查看物流（外卖订单）
  onViewDelivery(e) {
    const orderId = e.currentTarget.dataset.id

    wx.showModal({
      title: '配送详情',
      content: '骑手正在为您配送中...\n预计15分钟后送达',
      showCancel: false
    })
  },

  // 确认收货（外卖订单）
  onConfirmReceive(e) {
    const orderId = e.currentTarget.dataset.id

    wx.showModal({
      title: '确认收货',
      content: '确认您已收到商品？',
      success: (res) => {
        if (res.confirm) {
          // 更新订单状态为已完成
          const orders = this.data.orders.map(order => {
            if (order.id === orderId) {
              return {
                ...order,
                status: 'completed',
                statusText: '已完成',
                finishTime: this.formatTime(new Date())
              }
            }
            return order
          })

          this.setData({
            orders
          }, () => {
            this.updateFilteredOrders()
          })

          wx.showToast({
            title: '收货确认成功',
            icon: 'success'
          })
        }
      }
    })
  },

  // 跳转到点餐页面
  switchTab(e) {
    const url = e.currentTarget.dataset.url
    wx.switchTab({
      url
    })
  },

  // 格式化时间
  formatTime(date) {
    if (typeof date === 'string') {
      date = new Date(date)
    }

    const year = date.getFullYear()
    const month = (date.getMonth() + 1).toString().padStart(2, '0')
    const day = date.getDate().toString().padStart(2, '0')
    const hour = date.getHours().toString().padStart(2, '0')
    const minute = date.getMinutes().toString().padStart(2, '0')

    return `${year}-${month}-${day} ${hour}:${minute}`
  },

  // 显示登录弹窗
  showLoginModal() {
    this.setData({
      showLoginModal: true
    })
  },

  // 关闭登录弹窗
  onCloseLoginModal() {
    this.setData({
      showLoginModal: false
    })
  },

  // 登录成功回调
  onLoginSuccess(e) {
    this.setData({
      showLoginModal: false
    })

    // 重新检查登录状态
    this.checkLoginStatus()

    wx.showToast({
      title: '登录成功',
      icon: 'success'
    })
  },

  // 计算时间差
  getTimeDiff(createTime) {
    const now = new Date()
    const create = new Date(createTime)
    const diff = now - create

    if (diff < 60 * 1000) {
      return '刚刚'
    } else if (diff < 60 * 60 * 1000) {
      return `${Math.floor(diff / (60 * 1000))}分钟前`
    } else if (diff < 24 * 60 * 60 * 1000) {
      return `${Math.floor(diff / (60 * 60 * 1000))}小时前`
    } else {
      return `${Math.floor(diff / (24 * 60 * 60 * 1000))}天前`
    }
  }
})